import 'dart:convert';

import 'package:flutter/material.dart';
import 'package:flutter_fly/db/article_db.dart';
import 'package:flutter_fly/db/widget_db.dart';
import 'package:flutter_fly/entry/article_info.dart';
import 'package:flutter_fly/entry/widget_info.dart';
import 'package:flutter_fly/http/http_factory.dart';
import 'package:flutter_fly/pages/home/view_page.dart';
import 'package:flutter_fly/widgets/custom_web_view.dart';

const String question_text = '''
 　一、乔木种植后如何检查才能确认苗木是否成活

　　几乎所有的施工人员都知道苗木问题要及时发现，及时处理，但往往很多施工单位都是在苗木枯萎死亡后才发现。在此，我们希望施工人员能重视施工后的检查，及早发现问题进行解决，提高苗木的种植成活率。

　　解决方法：

　　1、了解苗木的情况，是否山苗，泥球大小，运输时间，种植季节等。

　　2、了解土方情况，是否深土层，PH值，土壤密实度，是否积水等问题。

　　3、用手有意识地推动树杆，看泥球与土壤是否结合紧密。

　　4、检查是否种植过深或泥球表面覆土过多，以免造成根系窒息死亡。

　　5、检查大型乔木是否有支撑或支撑是否牢固。以免大风吹杆造成根部松动，与土壤分离，致使树木死亡。

　　6、检查树杆及枝条是否有破损或修剪方法不当，以免病菌从伤口倾入树体内，造成树木衰弱。

　　7、观察树体上部情况，叶片是否有卷曲枯萎或非正常脱落，如有应及时用掏洞法查看根系情况，是否有腐烂，腐烂到何种程度，再来考虑是否能救活。因为根的好坏是树木成活的关键。

　　关键点：有问题及时掏洞看根系情况。

　　二、种植山苗为什么容易死亡

　　一般的施工人员都知道山苗种植成活率很低，但是随着大乔木的日渐减少，尤其是个别大乔木苗圃已难觅，所以不得不用山苗。

　　分析原因：

　　1、由于环境的因素决定了山苗大多是直根系，长期依靠一个主根或多个主根向下生长。如果移植，主根切断，树体自身的水养分流失，根压减小，不能吸收土壤中的水养分而导致死亡。

　　2、山上土层较薄，树木间的生存竞争使得树木的根系扎根很远，如果移植，能带的有效须根很少。

　　3、一般山上的生长环境较好，水份充足，湿度较高，排水又好，土壤多偏酸性，较适合苗木生长。如果移植，苗木不能及时适应种植地的环境。

　　4、山上的土壤多混有石块，所以苗木起挖，打泥球技术难度很大。

　　解决方法：

　　1、移植前半年最好先做好切根和树冠修剪工作。

　　2、起苗时注意保护泥球的完好不损伤，粗大根拔起而不是切断，保证树体的水养分的流失。

　　关键点：粗大根不要切断。
''';

///
/// des:首页
///
class HomeItemPage extends StatefulWidget {
  @override
  State<StatefulWidget> createState() => _HomeItemPageState();
}

class _HomeItemPageState extends State<HomeItemPage>
    with SingleTickerProviderStateMixin {
  TabController _tabController;
  List<ArticleInfo> _newsList = [];
  List<ArticleInfo> _technologyList = [];
  var _bannerList = [];
  var _newsKey = PageStorageKey('news');
  var _technologyKey = PageStorageKey('technology');

  @override
  void initState() {
    _loadData();
    super.initState();
    _tabController = TabController(length: 2, vsync: this);
  }

  ///
  /// 加载数据,先加载本地数据，然后加载服务器数据
  ///
  _loadData() async {
    await _loadLocalBannerData();
    await _loadLocalArticleData();
    await _loadRemoteData();
  }

  ///
  /// 加载本地Banner数据
  ///
  _loadLocalBannerData() async {
    var jsonStr = await DefaultAssetBundle.of(context)
        .loadString('assets/json/banner.json');
    _bannerList = json.decode(jsonStr);
    setState(() {});
  }

  ///
  /// 加载本地文章数据，先加载数据库，
  /// 如果数据库没有数据，加载本地json数据,然后将本地json数据保存到数据库
  ///
  _loadLocalArticleData() async {
    await ArticleDb().initDb();
    var list = await ArticleDb().findAll();
    if (list != null && list.length > 0) {
      _newsList = list.where((f) {
        return f.type == ArticleType.news;
      }).toList();

      _technologyList = list.where((f) {
        return f.type == ArticleType.technology;
      }).toList();
      setState(() {});
    } else {
      //加载json
      var newsJson = await DefaultAssetBundle.of(context)
          .loadString('assets/json/news.json');
      List<dynamic> newsData = json.decode(newsJson);
      newsData.forEach((f) {
        _newsList.add(ArticleInfo(
            title: f['title'],
            url: f['url'],
            author: f['author'],
            type: ArticleType.news));
      });

      var technologyJson = await DefaultAssetBundle.of(context)
          .loadString('assets/json/technology.json');
      List<dynamic> technologyData = json.decode(technologyJson);
      technologyData.forEach((f) {
        _technologyList.add(ArticleInfo(
            title: f['title'],
            url: f['url'],
            author: f['author'],
            type: ArticleType.technology));
      });
      _sortData();
      _saveData(_newsList);
      _saveData(_technologyList);
    }
  }

  ///
  /// 资讯和技术文章排序并重构
  ///
  _sortData() {
    _newsList.sort((a, b) {
      return b.time.compareTo(a.time);
    });
    _technologyList.sort((a, b) {
      return b.time.compareTo(a.time);
    });
    setState(() {});
  }

  ///
  /// 加载服务器数据
  ///
  _loadRemoteData() async {
    var result = await HttpFactory().getData();
    _handleBanner(result);
    var addArticleList = _handleArticle(result);
    _sortData();
    setState(() {});
    _saveData(addArticleList);
    _handlerWidgets(result);
  }

  ///
  /// 解析banner数据
  ///
  _handleBanner(dynamic data) {
    var result = data['banner'];
    if (result != null && result.length > 0) {
      _bannerList = result;
    }
  }

  ///
  /// 解析文章数据
  ///
  _handleArticle(dynamic data) {
    var result = data['article'];
    if (result != null && result.length > 0) {
      //去除重复
      result.removeWhere((f) {
        return _newsList.any((v) {
          return v.title == f['title'];
        });
      });
      result.removeWhere((f) {
        return _technologyList.any((v) {
          return v.title == f['title'];
        });
      });

      if (result.length > 0) {
        List<ArticleInfo> saveList = [];
        result.forEach((f) {
          print('新增文章:${f['title']}');
          if (f['type'] == 0) {
            var info = ArticleInfo(
                title: f['title'],
                url: f['url'],
                author: f['author'],
                type: ArticleType.news);
            _newsList.add(info);
            saveList.add(info);
          } else {
            var info = ArticleInfo(
                title: f['title'],
                url: f['url'],
                author: f['author'],
                type: ArticleType.technology);
            _technologyList.add(info);
            saveList.add(info);
          }
        });
        return saveList;
      }
    }
  }

  ///
  /// 解析控件数据
  ///
  _handlerWidgets(dynamic data) async {
    var result = data['widget'];
    if (result != null && result.length > 0) {
      List<WidgetInfo> list = [];
      result.forEach((f) {
        list.add(WidgetInfo.fromJson(f));
      });
      await WidgetDb().initDb();
      await WidgetDb().save(list);
    }
  }

  ///
  /// 保存文章数据到数据库
  ///
  _saveData(List<ArticleInfo> list) async {
    if (list == null || list.length == 0) {
      return;
    }
    await ArticleDb().initDb();
    await ArticleDb().save(list);
  }

  @override
  Widget build(BuildContext context) {
    return NestedScrollView(
      headerSliverBuilder: (context, bool) {
        return [
          SliverAppBar(
            floating: true,
            backgroundColor: Colors.transparent,
            expandedHeight: 230,
            flexibleSpace: Padding(
              padding: EdgeInsets.symmetric(vertical: 8),
              child: ViewPage(_bannerList),
            ),
          ),
          SliverPersistentHeader(
            pinned: true,
            delegate: StickyTabBarDelegate(
              child: TabBar(
                labelColor: Colors.black,
                controller: this._tabController,
                tabs: <Widget>[
                  Tab(text: '种植资讯'),
                  Tab(text: '问答广场'),
                ],
              ),
            ),
          ),
        ];
      },
      body: TabBarView(
        controller: this._tabController,
        children: <Widget>[
          _buildTabNewsList(_newsKey, _newsList),
          SingleChildScrollView(
            child: Padding(
              padding: EdgeInsets.symmetric(horizontal: 12, vertical: 30),
              child: Text(
                question_text,
              ),
            ),
          )
        ],
      ),
    );
  }

  ///
  /// 每一个tab下的list
  ///
  _buildTabNewsList(Key key, List<ArticleInfo> list) {
    return ListView.separated(
        key: key,
        itemBuilder: (context, index) {
          return ListTile(
            title: Text(list[index].title),
            subtitle: Text('作者：${list[index].author}'),
            onTap: () {
              toWebView(context, list[index].title, list[index].url);
            },
          );
        },
        separatorBuilder: (context, index) {
          return Divider(
            height: 8,
          );
        },
        itemCount: list.length);
  }

  @override
  void dispose() {
    super.dispose();
    _tabController.dispose();
  }
}

class StickyTabBarDelegate extends SliverPersistentHeaderDelegate {
  final TabBar child;

  StickyTabBarDelegate({@required this.child});

  @override
  Widget build(
      BuildContext context, double shrinkOffset, bool overlapsContent) {
    return Container(
      color: Theme.of(context).backgroundColor,
      child: this.child,
    );
  }

  @override
  double get maxExtent => this.child.preferredSize.height;

  @override
  double get minExtent => this.child.preferredSize.height;

  @override
  bool shouldRebuild(SliverPersistentHeaderDelegate oldDelegate) {
    return true;
  }
}
